home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 112 / EnigmaAmiga112CD.iso / dalla rivista / news / orbit / source / planet.c < prev    next >
C/C++ Source or Header  |  2000-05-01  |  24KB  |  979 lines
  1. /*
  2.     Amiga port by Oliver Gantert
  3.  
  4.     27.04.2000 - fixed some compiler warnings
  5. */
  6. /*
  7.  
  8. ORBIT, a freeware space combat simulator
  9. Copyright (C) 1999  Steve Belczyk <steve1@genesis.nred.ma.us>
  10.  
  11. This program is free software; you can redistribute it and/or
  12. modify it under the terms of the GNU General Public License
  13. as published by the Free Software Foundation; either version 2
  14. of the License, or (at your option) any later version.
  15.  
  16. This program is distributed in the hope that it will be useful,
  17. but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. GNU General Public License for more details.
  20.  
  21. You should have received a copy of the GNU General Public License
  22. along with this program; if not, write to the Free Software
  23. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24.  
  25. */
  26.  
  27. #include "orbit.h"
  28.  
  29. static float MaterialColor[] = {
  30.   1.0, 1.0, 1.0, 1.0}
  31. ; 
  32. static float specular[] = {
  33.   0.0, 0.0, 0.0, 1.0}
  34. ; 
  35. static float emission[] = {
  36.   0.0, 0.0, 0.0, 1.0}
  37. ;
  38.  
  39. void DrawPlanets()
  40. /*
  41.  *  Draw all the planets
  42.  */
  43. {
  44.   int p;
  45.  
  46.   /* Draw orbits */ 
  47.   if (draw_orbits) DrawOrbits(); 
  48.   
  49.   for (p=0; p<NPLANETS; p++)
  50.   {
  51.     if (!planet[p].hidden) DrawPlanet (p);
  52.   }
  53. }
  54.  
  55. void DrawPlanet (int p)
  56. /*
  57.  *  Draw the pretty planet
  58.  */
  59. {
  60.   double th, r2, v[3];
  61.   int pr;
  62.  
  63.   /* Set color to white, will be modulated with texture */
  64.   if (textures)
  65.   {
  66.     glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor);
  67.     glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, MaterialColor);
  68.   }
  69.   else
  70.   {
  71.     glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, planet[p].color);
  72.     glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, planet[p].color);
  73.   }
  74.   
  75.   glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); 
  76.   glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); 
  77.   glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS, 0.0); 
  78.  
  79.   glPushMatrix();
  80.  
  81.   /* How far away from view is this planet? */
  82.   Vsub (v, planet[p].pos, player.pos);
  83.   planet[p].absrange2 = Mag2(v);
  84.   planet[p].range2 = r2 = planet[p].absrange2 / planet[p].radius2;
  85.  
  86.   /* Translate to where the planet is */
  87.   Vsub (v, planet[p].pos, player.pos);
  88.   glTranslated (v[0], v[1], v[2]);
  89.   th = fmod (absT, 120.0);
  90.   th = 360.0*th / 120.0;
  91.  
  92.   /* Don't bother with oblicity or rotation if it's just a point */
  93.   if (r2 < 200.0*200.0)
  94.   {
  95.     /* Planet oblicity */
  96.     glRotated (planet[p].oblicity, 1.0, 0.0, 0.0);
  97.  
  98.     /* Moons get their primary's oblicity as well */
  99.     if (planet[p].is_moon)
  100.     {
  101.       pr = planet[p].primary;
  102.       glRotated (planet[pr].oblicity, 1.0, 0.0, 0.0);
  103.     }
  104.   }
  105.  
  106.   glPushMatrix();  /* Save un-rotated matrix */
  107.  
  108.   /* Planet rotation */
  109.   if (r2 < 200.0*200.0) glRotated (th, 0.0, 0.0, 1.0);
  110.  
  111.   if (r2 < 5.0 * 5.0)
  112.   {
  113.     if (textures) glEnable (GL_TEXTURE_2D);
  114.     glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  115.     glCallList (planet[p].list320);
  116.   }
  117.   else if (r2 < 25.0 * 25.0)
  118.   {
  119.     if (textures) glEnable (GL_TEXTURE_2D);
  120.     glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  121.     glCallList (planet[p].list80);
  122.   }
  123.   else if (r2 < 200.0 * 200.0)
  124.   {
  125.     if (textures) glEnable (GL_TEXTURE_2D);
  126.     glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  127.     glCallList (planet[p].list20);
  128.   }
  129.   else if (r2 < (5000.0 * 5000.0))
  130.   {
  131.     glDisable (GL_TEXTURE_2D);
  132.     glDisable (GL_LIGHTING);
  133.     glPointSize (2.0);
  134.     glBegin (GL_POINTS);
  135.     glColor3fv (planet[p].color);
  136.     glVertex3d (0.0, 0.0, 0.0);
  137.     glEnd();
  138.   }
  139.   else if (r2 < (50000.0 * 50000.0))
  140.   {
  141.     glDisable (GL_TEXTURE_2D);
  142.     glDisable (GL_LIGHTING);
  143.     glPointSize (1.0);
  144.     glBegin (GL_POINTS);
  145.     glColor3fv (planet[p].color);
  146.     glVertex3d (0.0, 0.0, 0.0);
  147.     glEnd();
  148.   }
  149.  
  150.   glDisable (GL_TEXTURE_2D);
  151.   glEnable (GL_LIGHTING);
  152.  
  153.   /* Pop rotate matrix */
  154.   glPopMatrix();
  155.  
  156.   glPopMatrix();
  157. }
  158.  
  159. void MakePlanetLists()
  160. /*
  161.  *  Define planet display lists
  162.  */
  163. {
  164.   int p;
  165.  
  166.   for (p=0; p<NPLANETS; p++)
  167.   {
  168.     /* Sun is special */
  169.     if (p == 0)
  170.     {
  171.       MakeSunList();
  172.     }
  173.     else
  174.     {
  175.       MakePlanetList (p);
  176.     }
  177.   }
  178.  
  179.   /* Make orbit lists */
  180.   MakeOrbitLists();
  181. }
  182.  
  183. void MakePlanetList (int p)
  184. /*
  185.  *  Make planet lists for planet p
  186.  */
  187. {
  188.   /* We make three different versions of the planet for display at various
  189.     distances */
  190.   if (glIsList (planet[p].list20)) glDeleteLists (planet[p].list20, 1);
  191.   planet[p].list20 = glGenLists (1);
  192.  
  193.   glNewList (planet[p].list20, GL_COMPILE);
  194.   maxtdiff = 0.47;
  195.   Sphere (planet[p].radius, stacks0, slices0);
  196.   glEndList();
  197.  
  198.   if (glIsList (planet[p].list80)) glDeleteLists (planet[p].list80, 1);
  199.   planet[p].list80 = glGenLists (1);
  200.  
  201.   glNewList (planet[p].list80, GL_COMPILE);
  202.   maxtdiff = 0.609384;
  203.   Sphere (planet[p].radius, stacks1, slices1);
  204.   glEndList();
  205.  
  206.   if (glIsList (planet[p].list320)) glDeleteLists (planet[p].list320, 1);
  207.   planet[p].list320 = glGenLists (1);
  208.  
  209.   glNewList (planet[p].list320, GL_COMPILE);
  210.   maxtdiff = 0.414069;
  211.   Sphere (planet[p].radius, stacks2, slices2);
  212.   glEndList();
  213. }
  214.  
  215. void MakeSunList()
  216. /*
  217.  *  Make Sol's display list
  218.  */
  219. {
  220.   if (glIsList (planet[0].list20)) glDeleteLists (planet[0].list20, 1);
  221.   planet[0].list20 = glGenLists (1);
  222.  
  223.   glNewList (planet[0].list20, GL_COMPILE);
  224.   glDisable (GL_LIGHTING);
  225.   glDisable (GL_TEXTURE_2D);
  226.   glColor3d (0.8, 0.8, 0.6);
  227.   Sphere (planet[0].radius, stacks0, slices0);
  228.   glEnable (GL_TEXTURE_2D);
  229.   glEnable (GL_LIGHTING);
  230.   glEndList();
  231.  
  232.   if (glIsList (planet[0].list80)) glDeleteLists (planet[0].list80, 1);
  233.   planet[0].list80 = glGenLists (1);
  234.  
  235.   glNewList (planet[0].list80, GL_COMPILE);
  236.   glDisable (GL_LIGHTING);
  237.   glDisable (GL_TEXTURE_2D);
  238.   glColor3d (0.8, 0.8, 0.6);
  239.   Sphere (planet[0].radius, stacks1, slices1);
  240.   glEnable (GL_TEXTURE_2D);
  241.   glEnable (GL_LIGHTING);
  242.   glEndList();
  243.  
  244.   if (glIsList (planet[0].list320)) glDeleteLists (planet[0].list320, 1);
  245.   planet[0].list320 = glGenLists (1);
  246.  
  247.   glNewList (planet[0].list320, GL_COMPILE);
  248.   glDisable (GL_LIGHTING);
  249.   glDisable (GL_TEXTURE_2D);
  250.   glColor3d (0.8, 0.8, 0.6);
  251.   Sphere (planet[0].radius, stacks2, slices2);
  252.   glEnable (GL_TEXTURE_2D);
  253.   glEnable (GL_LIGHTING);
  254.   glEndList();
  255. }
  256.  
  257. void ReadPlanetTexture (int p)
  258. /*
  259.  *  Read in the planet's texture
  260.  */
  261. {
  262.   FILE *fd;
  263.   int x, y, c, i;
  264.   char fn[64];
  265.  
  266.   /* Sun is special */
  267.   if (p == 0)
  268.   {
  269.     planet[p].color[0] = planet[p].color[1] = planet[p].color[2] = 1.0;
  270.     return;
  271.   }
  272.  
  273.   /* Zero planet average color */
  274.   planet[p].color[0] = planet[p].color[1] = planet[p].color[2] = 0.0;
  275.  
  276.   /* Get id for this texture */
  277.   if (planet[p].texid == (-1)) glGenTextures (1, &planet[p].texid);
  278.   glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  279.  
  280.   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  281.  
  282.   /* Put up a progress message */
  283.   Mprint ("Reading %s", planet[p].texfname);
  284.   Log ("ReadPlanetTexture: Reading texture file %s", planet[p].texfname);
  285.   DrawSplash();
  286.  
  287.   /* Open file */
  288.   sprintf (fn, "maps/%s", planet[p].texfname);
  289.   if (NULL == (fd = fopen (fn, "rb")))
  290.   {
  291.     Log ("ReadPlanetTexture: Can't open %s", planet[p].texfname);
  292.     FinishSound();
  293.     CloseLog();
  294.     exit (0);
  295.   }
  296.  
  297.   /* Read past PPM header */
  298.   while (10 != fgetc(fd));
  299.   while (10 != fgetc(fd));
  300.   while (10 != fgetc(fd));
  301.  
  302.   /* Read in the color data */
  303.   for (y=0; y<256; y++)
  304.   {
  305.     for (x=0; x<256; x++)
  306.     {
  307.       for (i=0; i<3; i++)
  308.       {
  309.         c = fgetc (fd);
  310.         if ( (c < 0) || (c > 255) )
  311.         {
  312.           Log ("ReadPlanetTexture: Error reading texture file %s", planet[p].texfname);
  313.           Log ("ReadPlanetTexture: x,y,i,c; %d %d %d %d", x, y, i, c);
  314.           FinishSound();
  315.           CloseLog();
  316.           exit (0);
  317.         }
  318.  
  319.         planet[p].tex[255-y][x][i] = 0xff & c;
  320.         planet[p].color[i] += (float) c;
  321.       }
  322.     }
  323.   }
  324.  
  325.   /* Compute average color */
  326.   for (i=0; i<3; i++) planet[p].color[i] /= (256.0 * 256.0 * 256.0);
  327.  
  328.   /* Set the texture */
  329.   glTexImage2D (GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, planet[p].tex);
  330.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  331.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  332.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  333.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  334.   glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  335.  
  336.   fclose (fd);
  337. }
  338.  
  339. void InitPlanets()
  340. /*
  341.  *  All sorts of planet initialization
  342.  */
  343. {
  344.   int p;
  345.  
  346.   for (p=0; p<NPLANETS; p++)
  347.   {
  348.     planet[p].custom = 1;
  349.     planet[p].texid = (-1);
  350.     planet[p].orbitlist = (-1);
  351.   }
  352.  
  353.   /* Randomize theta for each planet */
  354.   RandomPlanets();
  355.  
  356.   /* Reset planets */
  357.   ResetPlanets();
  358. }
  359.  
  360. void ResetPlanets()
  361. /*
  362.  *  Set planets back to the way they should be at start
  363.  */
  364. {
  365.   int p;
  366.  
  367.   p = 0;
  368.  
  369.   Log ("ResetPlanets: resetting planets");
  370.  
  371.   strcpy (planet[p].name, "Sol");
  372.   strcpy (planet[p].texfname, "sol.ppm");
  373.   planet[p].radius = 696000.000000 / KM_TO_UNITS1;
  374.   planet[p].dist = 0.000000 / KM_TO_UNITS2;
  375.   planet[p].is_moon = 0;
  376.   planet[p].primary = 0;
  377.   planet[p].oblicity = 0.0;
  378.   planet[p].angvel = 0.0;
  379.   p++;
  380.  
  381.   strcpy (planet[p].name, "Mercury");
  382.   strcpy (planet[p].texfname, "mercury.ppm");
  383.   planet[p].radius = 2440.000000 / KM_TO_UNITS1;
  384.   planet[p].dist = (realdistances ? 50.79 : 05.7900002) / KM_TO_UNITS2;
  385.   planet[p].is_moon = 0;
  386.   planet[p].primary = 0;
  387.   planet[p].angvel = 0.004166 / 87.969;
  388.   p++;
  389.  
  390.   strcpy (planet[p].name, "Venus");
  391.   strcpy (planet[p].texfname, "venus.ppm");
  392.   planet[p].radius = 6052.000000 / KM_TO_UNITS1;
  393.   planet[p].dist = (realdistances ? 108.2 : 10.8199997) / KM_TO_UNITS2;
  394.   planet[p].is_moon = 0;
  395.   planet[p].primary = 0;
  396.   planet[p].oblicity = 177.3;
  397.   planet[p].angvel = 0.004166 / 224.7;
  398.   p++;
  399.  
  400.   strcpy (planet[p].name, "Earth");
  401.   strcpy (planet[p].texfname, "earth.ppm");
  402.   planet[p].radius = 6371.000000 / KM_TO_UNITS1;
  403.   planet[p].dist = (realdistances ? 149.6 : 14.9600006) / KM_TO_UNITS2;
  404.   planet[p].is_moon = 0;
  405.   planet[p].primary = 0;
  406.   planet[p].oblicity = 23.45;
  407.   planet[p].angvel = 0.004166 / 365.256;
  408.   p++;
  409.  
  410.   strcpy (planet[p].name, "Moon");
  411.   strcpy (planet[p].texfname, "moon.ppm");
  412.   planet[p].radius = 1737.500000 / KM_TO_UNITS1;
  413.   planet[p].dist = 0.384400 / KM_TO_UNITS2;
  414.   planet[p].is_moon = 1;
  415.   planet[p].primary = 3;
  416.   planet[p].oblicity = 0.0;
  417.   planet[p].angvel = 0.004166 / 27.3;
  418.   p++;
  419.  
  420.   strcpy (planet[p].name, "Mars");
  421.   strcpy (planet[p].texfname, "mars.ppm");
  422.   planet[p].radius = 3390.000000 / KM_TO_UNITS1;
  423.   planet[p].dist = (realdistances ? 227.9 : 22.7899994) / KM_TO_UNITS2;
  424.   planet[p].is_moon = 0;
  425.   planet[p].primary = 0;
  426.   planet[p].oblicity = 25.19;
  427.   planet[p].angvel = 0.004166 / 686.98;
  428.   p++;
  429.  
  430.   strcpy (planet[p].name, "Phobos");
  431.   strcpy (planet[p].texfname, "phobos.ppm");
  432.   planet[p].radius = 13.000000 / KM_TO_UNITS1;
  433.   planet[p].dist = 0.009380 / KM_TO_UNITS2;
  434.   planet[p].is_moon = 1;
  435.   planet[p].primary = 5;
  436.   planet[p].oblicity = 0.0;
  437.   planet[p].angvel = 0.004166 / 0.319;
  438.   p++;
  439.  
  440.   strcpy (planet[p].name, "Deimos");
  441.   strcpy (planet[p].texfname, "deimos.ppm");
  442.   planet[p].radius = 8.000000 / KM_TO_UNITS1;
  443.   planet[p].dist = 0.022340 / KM_TO_UNITS2;
  444.   planet[p].is_moon = 1;
  445.   planet[p].primary = 5;
  446.   planet[p].oblicity = 0.0;
  447.   planet[p].angvel = 0.004166 / 1.262;
  448.   p++;
  449.  
  450.   strcpy (planet[p].name, "Jupiter");
  451.   strcpy (planet[p].texfname, "jupiter.ppm");
  452.   planet[p].radius = 69911.000000 / KM_TO_UNITS1;
  453.   /* planet[p].dist = 77.8400024 / KM_TO_UNITS2; */
  454.   planet[p].dist = (realdistances ? 778.4 : 50.0) / KM_TO_UNITS2;
  455.   planet[p].is_moon = 0;
  456.   planet[p].primary = 0;
  457.   planet[p].oblicity = 3.12;
  458.   planet[p].angvel = 0.004166 / 4332.0;
  459.   p++;
  460.  
  461.   strcpy (planet[p].name, "Io");
  462.   strcpy (planet[p].texfname, "io.ppm");
  463.   planet[p].radius = 1821.000000 / KM_TO_UNITS1;
  464.   planet[p].dist = 0.421000 / KM_TO_UNITS2;
  465.   planet[p].is_moon = 1;
  466.   planet[p].primary = 8;
  467.   planet[p].oblicity = 0.0;
  468.   planet[p].angvel = 0.004166 / 1.769;
  469.   p++;
  470.  
  471.   strcpy (planet[p].name, "Europa");
  472.   strcpy (planet[p].texfname, "europa.ppm");
  473.   planet[p].radius = 1565.000000 / KM_TO_UNITS1;
  474.   planet[p].dist = 0.671000 / KM_TO_UNITS2;
  475.   planet[p].is_moon = 1;
  476.   planet[p].primary = 8;
  477.   planet[p].oblicity = 0.0;
  478.   planet[p].angvel = 0.004166 / 3.552;
  479.   p++;
  480.  
  481.   strcpy (planet[p].name, "Ganymede");
  482.   strcpy (planet[p].texfname, "ganymede.ppm");
  483.   planet[p].radius = 2634.000000 / KM_TO_UNITS1;
  484.   planet[p].dist = 1.070000 / KM_TO_UNITS2;
  485.   planet[p].is_moon = 1;
  486.   planet[p].primary = 8;
  487.   planet[p].oblicity = 0.0;
  488.   planet[p].angvel = 0.004166 / 7.155;
  489.   p++;
  490.  
  491.   strcpy (planet[p].name, "Callisto");
  492.   strcpy (planet[p].texfname, "callisto.ppm");
  493.   planet[p].radius = 2403.000000 / KM_TO_UNITS1;
  494.   planet[p].dist = 1.883000 / KM_TO_UNITS2;
  495.   planet[p].is_moon = 1;
  496.   planet[p].primary = 8;
  497.   planet[p].oblicity = 0.0;
  498.   planet[p].angvel = 0.004166 / 16.69;
  499.   p++;
  500.  
  501.   strcpy (planet[p].name, "Saturn");
  502.   strcpy (planet[p].texfname, "saturn.ppm");
  503.   planet[p].radius = 58232.000000 / KM_TO_UNITS1;
  504.   /* planet[p].dist = 142.7000000 / KM_TO_UNITS2; */
  505.   planet[p].dist = (realdistances ? 1427.0 : 75.0) / KM_TO_UNITS2;
  506.   planet[p].is_moon = 0;
  507.   planet[p].primary = 0;
  508.   planet[p].oblicity = 26.73;
  509.   planet[p].angvel = 0.004166 / 10759.0;
  510.   p++;
  511.  
  512.   strcpy (planet[p].name, "Mimas");
  513.   strcpy (planet[p].texfname, "mimas.ppm");
  514.   planet[p].radius = 198.800003 / KM_TO_UNITS1;
  515.   planet[p].dist = 0.185000 / KM_TO_UNITS2;
  516.   planet[p].is_moon = 1;
  517.   planet[p].primary = 13;
  518.   planet[p].oblicity = 0.0;
  519.   planet[p].angvel = 0.004166 / 0.942;
  520.   p++;
  521.  
  522.   strcpy (planet[p].name, "Enceladus");
  523.   strcpy (planet[p].texfname, "enceladus.ppm");
  524.   planet[p].radius = 249.100006 / KM_TO_UNITS1;
  525.   planet[p].dist = 0.238000 / KM_TO_UNITS2;
  526.   planet[p].is_moon = 1;
  527.   planet[p].primary = 13;
  528.   planet[p].oblicity = 0.0;
  529.   planet[p].angvel = 0.004166 / 1.37;
  530.   p++;
  531.  
  532.   strcpy (planet[p].name, "Tethys");
  533.   strcpy (planet[p].texfname, "tethys.ppm");
  534.   planet[p].radius = 529.900024 / KM_TO_UNITS1;
  535.   planet[p].dist = 0.294000 / KM_TO_UNITS2;
  536.   planet[p].is_moon = 1;
  537.   planet[p].primary = 13;
  538.   planet[p].oblicity = 0.0;
  539.   planet[p].angvel = 0.004166 / 1.888;
  540.   p++;
  541.  
  542.   strcpy (planet[p].name, "Dione");
  543.   strcpy (planet[p].texfname, "dione.ppm");
  544.   planet[p].radius = 560.000000 / KM_TO_UNITS1;
  545.   planet[p].dist = 0.377000 / KM_TO_UNITS2;
  546.   planet[p].is_moon = 1;
  547.   planet[p].primary = 13;
  548.   planet[p].oblicity = 0.0;
  549.   planet[p].angvel = 0.004166 / 2.737;
  550.   p++;
  551.  
  552.   strcpy (planet[p].name, "Rhea");
  553.   strcpy (planet[p].texfname, "rhea.ppm");
  554.   planet[p].radius = 764.000000 / KM_TO_UNITS1;
  555.   planet[p].dist = 0.527000 / KM_TO_UNITS2;
  556.   planet[p].is_moon = 1;
  557.   planet[p].primary = 13;
  558.   planet[p].oblicity = 0.0;
  559.   planet[p].angvel = 0.004166 / 4.518;
  560.   p++;
  561.  
  562.   strcpy (planet[p].name, "Titan");
  563.   strcpy (planet[p].texfname, "titan.ppm");
  564.   planet[p].radius = 2575.000000 / KM_TO_UNITS1;
  565.   planet[p].dist = 1.221000 / KM_TO_UNITS2;
  566.   planet[p].is_moon = 1;
  567.   planet[p].primary = 13;
  568.   planet[p].oblicity = 0.0;
  569.   planet[p].angvel = 0.004166 / 15.9;
  570.   p++;
  571.  
  572.   strcpy (planet[p].name, "Iapetus");
  573.   strcpy (planet[p].texfname, "iapetus.ppm");
  574.   planet[p].radius = 718.000000 / KM_TO_UNITS1;
  575.   planet[p].dist = 3.561000 / KM_TO_UNITS2;
  576.   planet[p].is_moon = 1;
  577.   planet[p].primary = 13;
  578.   planet[p].oblicity = 0.0;
  579.   planet[p].angvel = 0.004166 / 79.33;
  580.   p++;
  581.  
  582.   strcpy (planet[p].name, "Uranus");
  583.   strcpy (planet[p].texfname, "uranus.ppm");
  584.   planet[p].radius = 25362.000000 / KM_TO_UNITS1;
  585.   /* planet[p].dist = 287.1000000 / KM_TO_UNITS2; */
  586.   planet[p].dist = (realdistances ? 2871.0 : 100.0) / KM_TO_UNITS2;
  587.   planet[p].is_moon = 0;
  588.   planet[p].primary = 0;
  589.   planet[p].oblicity = 97.86;
  590.   planet[p].angvel = 0.004166 / 30685.0;
  591.   p++;
  592.  
  593.   strcpy (planet[p].name, "Miranda");
  594.   strcpy (planet[p].texfname, "miranda.ppm");
  595.   planet[p].radius = 235.000000 / KM_TO_UNITS1;
  596.   planet[p].dist = 0.130000 / KM_TO_UNITS2;
  597.   planet[p].is_moon = 1;
  598.   planet[p].primary = 21;
  599.   planet[p].oblicity = 0.0;
  600.   planet[p].angvel = 0.004166 / 1.413;
  601.   p++;
  602.  
  603.   strcpy (planet[p].name, "Ariel");
  604.   strcpy (planet[p].texfname, "ariel.ppm");
  605.   planet[p].radius = 580.000000 / KM_TO_UNITS1;
  606.   planet[p].dist = 0.191000 / KM_TO_UNITS2;
  607.   planet[p].is_moon = 1;
  608.   planet[p].primary = 21;
  609.   planet[p].oblicity = 0.0;
  610.   planet[p].angvel = 0.004166 / 2.52;
  611.   p++;
  612.  
  613.   strcpy (planet[p].name, "Umbriel");
  614.   strcpy (planet[p].texfname, "umbriel.ppm");
  615.   planet[p].radius = 585.000000 / KM_TO_UNITS1;
  616.   planet[p].dist = 0.266000 / KM_TO_UNITS2;
  617.   planet[p].is_moon = 1;
  618.   planet[p].primary = 21;
  619.   planet[p].oblicity = 0.0;
  620.   planet[p].angvel = 0.004166 / 4.144;
  621.   p++;
  622.  
  623.   strcpy (planet[p].name, "Titania");
  624.   strcpy (planet[p].texfname, "titania.ppm");
  625.   planet[p].radius = 789.000000 / KM_TO_UNITS1;
  626.   planet[p].dist = 0.436000 / KM_TO_UNITS2;
  627.   planet[p].is_moon = 1;
  628.   planet[p].primary = 21;
  629.   planet[p].oblicity = 0.0;
  630.   planet[p].angvel = 0.004166 / 8.706;
  631.   p++;
  632.  
  633.   strcpy (planet[p].name, "Oberon");
  634.   strcpy (planet[p].texfname, "oberon.ppm");
  635.   planet[p].radius = 761.000000 / KM_TO_UNITS1;
  636.   planet[p].dist = 0.583000 / KM_TO_UNITS2;
  637.   planet[p].is_moon = 1;
  638.   planet[p].primary = 21;
  639.   planet[p].oblicity = 0.0;
  640.   planet[p].angvel = 0.004166 / 13.463;
  641.   p++;
  642.  
  643.   strcpy (planet[p].name, "Neptune");
  644.   strcpy (planet[p].texfname, "neptune.ppm");
  645.   planet[p].radius = 24766.000000 / KM_TO_UNITS1;
  646.   /* planet[p].dist = 449.8000000 / KM_TO_UNITS2; */
  647.   planet[p].dist = (realdistances ? 4498.0 : 125.0) / KM_TO_UNITS2;
  648.   planet[p].is_moon = 0;
  649.   planet[p].primary = 0;
  650.   planet[p].oblicity = 29.56;
  651.   planet[p].angvel = 0.004166 / 60189.0;
  652.   p++;
  653.  
  654.   strcpy (planet[p].name, "Triton");
  655.   strcpy (planet[p].texfname, "triton.ppm");
  656.   planet[p].radius = 1352.599976 / KM_TO_UNITS1;
  657.   planet[p].dist = 0.355000 / KM_TO_UNITS2;
  658.   planet[p].is_moon = 1;
  659.   planet[p].primary = 27;
  660.   planet[p].oblicity = 0.0;
  661.   planet[p].angvel = 0.004166 / -5.877;
  662.   p++;
  663.  
  664.   strcpy (planet[p].name, "Proteus");
  665.   strcpy (planet[p].texfname, "proteus.ppm");
  666.   planet[p].radius = 218.000000 / KM_TO_UNITS1;
  667.   planet[p].dist = 0.118000 / KM_TO_UNITS2;
  668.   planet[p].is_moon = 1;
  669.   planet[p].primary = 27;
  670.   planet[p].oblicity = 0.0;
  671.   planet[p].angvel = 0.004166 / 1.122;
  672.   p++;
  673.  
  674.   strcpy (planet[p].name, "Pluto");
  675.   strcpy (planet[p].texfname, "pluto.ppm");
  676.   planet[p].radius = 1137.000000 / KM_TO_UNITS1;
  677.   /* planet[p].dist = 590.6000000 / KM_TO_UNITS2; */
  678.   planet[p].dist = (realdistances ? 5906.0 : 150.0) / KM_TO_UNITS2;
  679.   planet[p].is_moon = 0;
  680.   planet[p].primary = 0;
  681.   planet[p].oblicity = 122.0;
  682.   planet[p].angvel = 0.004166 / 90465.0;
  683.   p++;
  684.  
  685.   strcpy (planet[p].name, "Charon");
  686.   strcpy (planet[p].texfname, "charon.ppm");
  687.   planet[p].radius = 586.000000 / KM_TO_UNITS1;
  688.   planet[p].dist = 0.019000 / KM_TO_UNITS2;
  689.   planet[p].is_moon = 1;
  690.   planet[p].primary = 30;
  691.   planet[p].oblicity = 0.0;
  692.   planet[p].angvel = 0.004166 / 6.387;
  693.   p++;
  694.  
  695.   /* Randomize planet positions */
  696.   PositionPlanets();
  697.  
  698.   /* Read textures, etc */
  699.   for (p=0; p<NPLANETS; p++)
  700.   {
  701.     if (planet[p].custom)
  702.     {
  703.       ReadPlanetTexture (p);
  704.       planet[p].custom = 0;
  705.     }
  706.  
  707.     planet[p].radius2 = planet[p].radius * planet[p].radius;
  708.     planet[p].hidden = 0;
  709.  
  710.     /* Set planet's mass */
  711.     planet[p].mass = planet[p].radius * planet[p].radius * planet[p].radius;
  712.   }
  713.  
  714.   /* Define planet display lists */
  715.   MakePlanetLists();
  716. }
  717.  
  718. void RandomPlanets()
  719. /*
  720.  *  Randomly set solar angle for each planet
  721.  */
  722. {
  723.   int p;
  724.  
  725.   Log ("RandomPlanets: Randomizing planets");
  726.  
  727.   for (p=0; p<NPLANETS; p++)
  728.   {
  729.     planet[p].theta = 2.0 * rnd (6.28);
  730.   }
  731. }
  732.  
  733. void PositionPlanets()
  734. /*
  735.  *  Turn planet angles into Cartesian coordinates
  736.  */
  737. {
  738.   int p, pr;
  739.   double th, v[3], v1[3];
  740.  
  741.   /* Position the planets */
  742.   for (p=0; p<NPLANETS; p++)
  743.   {
  744.     th = planet[p].theta;
  745.  
  746.     planet[p].pos[0] = planet[p].dist * sin (th);
  747.     planet[p].pos[1] = planet[p].dist * cos (th);
  748.     planet[p].pos[2] = 0.0;
  749.  
  750.     /* If moon, compute absolute position based on primary's
  751.      position and oblicity */
  752.     if (planet[p].is_moon)
  753.     {
  754.       pr = planet[p].primary;
  755.       th = -planet[pr].oblicity * 3.1415926535 / 180.0;
  756.       v[0] = 1.0;
  757.       v[1] = 0.0;
  758.       v[2] = 0.0;
  759.       RotateAbout (v1, planet[p].pos, v, th);
  760.       Vset (planet[p].pos, v1);
  761.       Vadd (planet[p].pos, planet[p].pos, planet[pr].pos);
  762.     }
  763.   }
  764. }
  765.  
  766. int InsidePlanet (double *v)
  767. /*
  768.  *  Check if v is inside a planet.  If yes, return planet
  769.  *  index, else -1
  770.  */
  771. {
  772.   int p;
  773.   double v1[3], r2;
  774.  
  775.   for (p=0; p<NPLANETS; p++)
  776.   {
  777.     if (!planet[p].hidden)
  778.     {
  779.       Vsub (v1, v, planet[p].pos);
  780.       r2 = Mag2 (v1);
  781.  
  782.       /* Inside? */
  783.       if (r2 < planet[p].radius2)
  784.       {
  785.         /* Yep */
  786.         return (p);
  787.       }
  788.     }
  789.   }
  790.  
  791.   /* Nope */
  792.   return (-1);
  793. }
  794.  
  795. void ShowPlanetNames()
  796. {
  797.   int p;
  798.   unsigned char v;
  799.   double v1[3]; 
  800.   char buf[128];
  801.  
  802.   for (p=0; p<NPLANETS; p++)
  803.   {
  804.     if (!planet[p].hidden)
  805.     {
  806.       if (planet[p].is_moon)
  807.       glColor3d (0.0, 0.8, 0.8);
  808.       else
  809.       glColor3d (0.0, 0.0, 0.8);
  810.  
  811.       Vsub (v1, planet[p].pos, player.pos);
  812.       glRasterPos3dv (v1);
  813.       glGetBooleanv (GL_CURRENT_RASTER_POSITION_VALID, &v);
  814.       if (v)
  815.       {
  816.         if (!planet[p].is_moon)
  817.         {
  818.           if (planet[p].absrange2 < 100.0*planet[p].radius*planet[p].radius) 
  819.           {
  820.             sprintf (buf, "%s:%.0lf", planet[p].name, 
  821.             KM_TO_UNITS1*(sqrt(planet[p].absrange2)-planet[p].radius)); 
  822.           }
  823.           else 
  824.           {
  825.             strcpy (buf, planet[p].name); 
  826.           }
  827.           Print (GLUT_BITMAP_HELVETICA_10, buf);
  828.         }
  829.         else
  830.         {
  831.           if (planet[p].range2 < (2000.0 * 2000.0))
  832.           {
  833.             if (planet[p].absrange2 < 100.0*planet[p].radius*planet[p].radius) 
  834.             {
  835.               sprintf (buf, "%s:%.0lf", planet[p].name, 
  836.               KM_TO_UNITS1*(sqrt(planet[p].absrange2)-planet[p].radius)); 
  837.             }
  838.             else 
  839.             {
  840.               strcpy (buf, planet[p].name); 
  841.             }
  842.             Print (GLUT_BITMAP_HELVETICA_10, buf);
  843.           }
  844.         }
  845.       }
  846.     }
  847.   }
  848. }
  849.  
  850. void Sphere (double r, int slices, int sectors)
  851. {
  852.   GLUquadricObj *obj;
  853.  
  854.   obj = gluNewQuadric();
  855.   
  856.   gluQuadricDrawStyle (obj, GLU_FILL);
  857.   gluQuadricNormals (obj, GLU_SMOOTH);
  858.   gluQuadricTexture (obj, GL_TRUE);
  859.   gluSphere (obj, (float)r, sectors, slices);
  860. }
  861.  
  862. int FindPlanetByName (char *c)
  863. /*
  864.  *  Find planet given name, else -1
  865.  */
  866. {
  867.   int p;
  868.  
  869.   for (p=0; p<NPLANETS; p++)
  870.   {
  871.     if (!strcasecmp (c, planet[p].name)) return (p);
  872.   }
  873.  
  874.   return (-1);
  875. }
  876.  
  877. void MakeOrbitLists()
  878. /*
  879.  *  Construct display lists for orbits
  880.  */
  881. {
  882.   int p;
  883.   double th, d, s, c;
  884.  
  885.   d = 360.0 / ((double) ORBIT_SECTORS);
  886.  
  887.   /* Loop through planets */
  888.   for (p=1; p<NPLANETS; p++)
  889.   {
  890.     /* Delete old list */
  891.     if (glIsList (planet[p].orbitlist)) glDeleteLists (planet[p].orbitlist, 1);
  892.  
  893.     /* Make new list */
  894.     planet[p].orbitlist = glGenLists (1);
  895.     glNewList (planet[p].orbitlist, GL_COMPILE);
  896.  
  897.     glBegin (GL_LINE_LOOP);
  898.  
  899.     /* Set color */
  900.     if (planet[p].is_moon)
  901.     {
  902.       glColor3f (0.0, 0.8, 0.8);
  903.     }
  904.     else
  905.     {
  906.       glColor3f (0.0, 0.0, 1.0);
  907.     }
  908.  
  909.     /* Loop through circle */
  910.     for (th=0.0; th<360.0; th+=d)
  911.     {
  912.       s = sin (th*3.1415926535/180.0);
  913.       c = cos (th*3.1415926535/180.0);
  914.  
  915.       glVertex3d (planet[p].dist*s, planet[p].dist*c, 0.0);
  916.     }
  917.  
  918.     glEnd();
  919.     glEndList();
  920.   }
  921. }
  922.  
  923. void DrawOrbits()
  924. /*
  925.  *  Draw orbital paths
  926.  */
  927. {
  928.   int p;
  929.   double v[3];
  930.  
  931.   glDisable (GL_TEXTURE_2D);
  932.   glDisable (GL_LIGHTING);
  933.  
  934.   glPushMatrix();
  935.   Vsub (v, planet[0].pos, player.pos);
  936.   glTranslated (v[0], v[1], v[2]);
  937.  
  938.   for (p=1; p<NPLANETS; p++)
  939.   {
  940.     if (!planet[p].hidden)
  941.     {
  942.       if (planet[p].is_moon)
  943.       {
  944.         if (planet[planet[p].primary].range2 > 200.0*200.0) continue;
  945.  
  946.         glPushMatrix();
  947.         Vsub (v, player.pos, planet[0].pos);
  948.         glTranslated (v[0], v[1], v[2]);
  949.  
  950.         Vsub (v, planet[planet[p].primary].pos, player.pos);
  951.         glTranslated (v[0], v[1], v[2]);
  952.  
  953.         glRotated (planet[planet[p].primary].oblicity, 1.0, 0.0, 0.0);
  954.       }
  955.       glCallList (planet[p].orbitlist);
  956.       if (planet[p].is_moon) glPopMatrix();
  957.     }
  958.   }
  959.  
  960.   glPopMatrix();
  961. }
  962.  
  963. void MovePlanets()
  964. /*
  965.  *  Move planets in their orbits
  966.  */
  967. {
  968.   int p;
  969.  
  970.   for (p=1; p<NPLANETS; p++)
  971.   {
  972.     planet[p].theta -= planet[p].angvel * deltaT * compression 
  973.     * 3.1415926535 / 180.0; 
  974.     if (planet[p].theta < 0.0) planet[p].theta += 2.0 * 3.1415926535; 
  975.   }
  976.  
  977.   PositionPlanets();
  978. }
  979.